# **********************************************************************
#
# Copyright (c) 2003-2008 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************

# Ice version 3.3.0
# Generated from file `persist.ice'

import Ice, IcePy, __builtin__

# Start of module AcornPersist
_M_AcornPersist = Ice.openModule('AcornPersist')
__name__ = 'AcornPersist'

if not _M_AcornPersist.__dict__.has_key('UnionDiscriminator'):
    _M_AcornPersist.UnionDiscriminator = Ice.createTempClass()
    class UnionDiscriminator(Ice.Object):
        def __init__(self):
            pass

        def ice_ids(self, current=None):
            return ('::AcornPersist::UnionDiscriminator', '::Ice::Object')

        def ice_id(self, current=None):
            return '::AcornPersist::UnionDiscriminator'

        def ice_staticId():
            return '::AcornPersist::UnionDiscriminator'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_AcornPersist._t_UnionDiscriminator)

        __repr__ = __str__

    _M_AcornPersist.UnionDiscriminatorPrx = Ice.createTempClass()
    class UnionDiscriminatorPrx(Ice.ObjectPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_AcornPersist.UnionDiscriminatorPrx.ice_checkedCast(proxy, '::AcornPersist::UnionDiscriminator', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_AcornPersist.UnionDiscriminatorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_AcornPersist._t_UnionDiscriminatorPrx = IcePy.defineProxy('::AcornPersist::UnionDiscriminator', UnionDiscriminatorPrx)

    _M_AcornPersist._t_UnionDiscriminator = IcePy.defineClass('::AcornPersist::UnionDiscriminator', UnionDiscriminator, (), False, None, (), ())
    UnionDiscriminator.ice_type = _M_AcornPersist._t_UnionDiscriminator

    _M_AcornPersist.UnionDiscriminator = UnionDiscriminator
    del UnionDiscriminator

    _M_AcornPersist.UnionDiscriminatorPrx = UnionDiscriminatorPrx
    del UnionDiscriminatorPrx

if not _M_AcornPersist.__dict__.has_key('MemberInt'):
    _M_AcornPersist.MemberInt = Ice.createTempClass()
    class MemberInt(_M_AcornPersist.UnionDiscriminator):
        def __init__(self, i=0):
            _M_AcornPersist.UnionDiscriminator.__init__(self)
            self.i = i

        def ice_ids(self, current=None):
            return ('::AcornPersist::MemberInt', '::AcornPersist::UnionDiscriminator', '::Ice::Object')

        def ice_id(self, current=None):
            return '::AcornPersist::MemberInt'

        def ice_staticId():
            return '::AcornPersist::MemberInt'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_AcornPersist._t_MemberInt)

        __repr__ = __str__

    _M_AcornPersist.MemberIntPrx = Ice.createTempClass()
    class MemberIntPrx(_M_AcornPersist.UnionDiscriminatorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_AcornPersist.MemberIntPrx.ice_checkedCast(proxy, '::AcornPersist::MemberInt', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_AcornPersist.MemberIntPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_AcornPersist._t_MemberIntPrx = IcePy.defineProxy('::AcornPersist::MemberInt', MemberIntPrx)

    _M_AcornPersist._t_MemberInt = IcePy.defineClass('::AcornPersist::MemberInt', MemberInt, (), False, _M_AcornPersist._t_UnionDiscriminator, (), (('i', (), IcePy._t_int),))
    MemberInt.ice_type = _M_AcornPersist._t_MemberInt

    _M_AcornPersist.MemberInt = MemberInt
    del MemberInt

    _M_AcornPersist.MemberIntPrx = MemberIntPrx
    del MemberIntPrx

if not _M_AcornPersist.__dict__.has_key('MemberFloat'):
    _M_AcornPersist.MemberFloat = Ice.createTempClass()
    class MemberFloat(_M_AcornPersist.UnionDiscriminator):
        def __init__(self, f=0.0):
            _M_AcornPersist.UnionDiscriminator.__init__(self)
            self.f = f

        def ice_ids(self, current=None):
            return ('::AcornPersist::MemberFloat', '::AcornPersist::UnionDiscriminator', '::Ice::Object')

        def ice_id(self, current=None):
            return '::AcornPersist::MemberFloat'

        def ice_staticId():
            return '::AcornPersist::MemberFloat'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_AcornPersist._t_MemberFloat)

        __repr__ = __str__

    _M_AcornPersist.MemberFloatPrx = Ice.createTempClass()
    class MemberFloatPrx(_M_AcornPersist.UnionDiscriminatorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_AcornPersist.MemberFloatPrx.ice_checkedCast(proxy, '::AcornPersist::MemberFloat', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_AcornPersist.MemberFloatPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_AcornPersist._t_MemberFloatPrx = IcePy.defineProxy('::AcornPersist::MemberFloat', MemberFloatPrx)

    _M_AcornPersist._t_MemberFloat = IcePy.defineClass('::AcornPersist::MemberFloat', MemberFloat, (), False, _M_AcornPersist._t_UnionDiscriminator, (), (('f', (), IcePy._t_float),))
    MemberFloat.ice_type = _M_AcornPersist._t_MemberFloat

    _M_AcornPersist.MemberFloat = MemberFloat
    del MemberFloat

    _M_AcornPersist.MemberFloatPrx = MemberFloatPrx
    del MemberFloatPrx

if not _M_AcornPersist.__dict__.has_key('MemberString'):
    _M_AcornPersist.MemberString = Ice.createTempClass()
    class MemberString(_M_AcornPersist.UnionDiscriminator):
        def __init__(self, s=''):
            _M_AcornPersist.UnionDiscriminator.__init__(self)
            self.s = s

        def ice_ids(self, current=None):
            return ('::AcornPersist::MemberString', '::AcornPersist::UnionDiscriminator', '::Ice::Object')

        def ice_id(self, current=None):
            return '::AcornPersist::MemberString'

        def ice_staticId():
            return '::AcornPersist::MemberString'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_AcornPersist._t_MemberString)

        __repr__ = __str__

    _M_AcornPersist.MemberStringPrx = Ice.createTempClass()
    class MemberStringPrx(_M_AcornPersist.UnionDiscriminatorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_AcornPersist.MemberStringPrx.ice_checkedCast(proxy, '::AcornPersist::MemberString', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_AcornPersist.MemberStringPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_AcornPersist._t_MemberStringPrx = IcePy.defineProxy('::AcornPersist::MemberString', MemberStringPrx)

    _M_AcornPersist._t_MemberString = IcePy.defineClass('::AcornPersist::MemberString', MemberString, (), False, _M_AcornPersist._t_UnionDiscriminator, (), (('s', (), IcePy._t_string),))
    MemberString.ice_type = _M_AcornPersist._t_MemberString

    _M_AcornPersist.MemberString = MemberString
    del MemberString

    _M_AcornPersist.MemberStringPrx = MemberStringPrx
    del MemberStringPrx

if not _M_AcornPersist.__dict__.has_key('Persist'):
    _M_AcornPersist.Persist = Ice.createTempClass()
    class Persist(Ice.Object):
        def __init__(self):
            if __builtin__.type(self) == _M_AcornPersist.Persist:
                raise RuntimeError('AcornPersist.Persist is an abstract class')

        def ice_ids(self, current=None):
            return ('::AcornPersist::Persist', '::Ice::Object')

        def ice_id(self, current=None):
            return '::AcornPersist::Persist'

        def ice_staticId():
            return '::AcornPersist::Persist'
        ice_staticId = staticmethod(ice_staticId)

        #
        # Operation signatures.
        #
        # def put(self, category, key, value, radio, current=None):
        # def get(self, category, key, radio, current=None):
        # def save(self, current=None):
        # def getProfiles(self, current=None):
        # def setProfile(self, profile, current=None):
        # def getProfile(self, current=None):

        def __str__(self):
            return IcePy.stringify(self, _M_AcornPersist._t_Persist)

        __repr__ = __str__

    _M_AcornPersist.PersistPrx = Ice.createTempClass()
    class PersistPrx(Ice.ObjectPrx):

        def put(self, category, key, value, radio, _ctx=None):
            return _M_AcornPersist.Persist._op_put.invoke(self, ((category, key, value, radio), _ctx))

        def get(self, category, key, radio, _ctx=None):
            return _M_AcornPersist.Persist._op_get.invoke(self, ((category, key, radio), _ctx))

        def save(self, _ctx=None):
            return _M_AcornPersist.Persist._op_save.invoke(self, ((), _ctx))

        def getProfiles(self, _ctx=None):
            return _M_AcornPersist.Persist._op_getProfiles.invoke(self, ((), _ctx))

        def setProfile(self, profile, _ctx=None):
            return _M_AcornPersist.Persist._op_setProfile.invoke(self, ((profile, ), _ctx))

        def getProfile(self, _ctx=None):
            return _M_AcornPersist.Persist._op_getProfile.invoke(self, ((), _ctx))

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_AcornPersist.PersistPrx.ice_checkedCast(proxy, '::AcornPersist::Persist', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_AcornPersist.PersistPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_AcornPersist._t_PersistPrx = IcePy.defineProxy('::AcornPersist::Persist', PersistPrx)

    _M_AcornPersist._t_Persist = IcePy.defineClass('::AcornPersist::Persist', Persist, (), True, None, (), ())
    Persist.ice_type = _M_AcornPersist._t_Persist

    Persist._op_put = IcePy.Operation('put', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_string), ((), IcePy._t_string), ((), _M_AcornPersist._t_UnionDiscriminator), ((), IcePy._t_int)), (), None, ())
    Persist._op_get = IcePy.Operation('get', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_string), ((), IcePy._t_string), ((), IcePy._t_int)), (), _M_AcornPersist._t_UnionDiscriminator, ())
    Persist._op_save = IcePy.Operation('save', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), None, ())
    Persist._op_getProfiles = IcePy.Operation('getProfiles', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_string, ())
    Persist._op_setProfile = IcePy.Operation('setProfile', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_string),), (), None, ())
    Persist._op_getProfile = IcePy.Operation('getProfile', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_string, ())

    _M_AcornPersist.Persist = Persist
    del Persist

    _M_AcornPersist.PersistPrx = PersistPrx
    del PersistPrx

# End of module AcornPersist
